package tbs.framework.interfaces;

import org.jetbrains.annotations.NotNull;

import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.function.Consumer;

/**
 * 定义一个缓冲消费者接口，用于处理数据缓冲区。
 *
 * @param <T> 数据类型
 * @author Abstergo
 */
public interface IBufferedConsumer<T> extends Consumer<T> {

    /**
     * 刷新缓冲区，将缓冲区中的数据全部输出。
     */
    void flush();

    /**
     * 获取缓冲区限制的大小。
     *
     * @return 缓冲区限制的大小
     */
    int getBufferLimitedSize();

    /**
     * 获取缓冲区中已缓冲的数据数量。
     *
     * @return 缓冲区中已缓冲的数据数量
     */
    int getBufferedSize();

    /**
     * 将一个数据项添加到缓冲区。
     *
     * @param t 数据项
     * @return 缓冲消费者对象
     */
    @NotNull IBufferedConsumer<T> buffer(T t);

    /**
     * 将一个集合添加到缓冲区。
     *
     * @param collection 集合
     * @return 缓冲消费者对象
     */
    default @NotNull IBufferedConsumer<T> buffer(@NotNull Collection<T> collection) {
        return buffer(collection.iterator());
    }

    /**
     * 将一个迭代器添加到缓冲区。
     *
     * @param iterator 迭代器
     * @return 缓冲消费者对象
     */
    default @NotNull IBufferedConsumer<T> buffer(@NotNull Iterator<T> iterator) {
        return buffer(0, Integer.MAX_VALUE, iterator);
    }

    /**
     * 将一个列表添加到缓冲区。
     *
     * @param list 列表
     * @return 缓冲消费者对象
     */
    default @NotNull IBufferedConsumer<T> buffer(@NotNull List<T> list) {
        return buffer(list.iterator());
    }

    /**
     * 将一个可变参数添加到缓冲区。
     *
     * @param t 可变参数
     * @return 缓冲消费者对象
     */
    default @NotNull IBufferedConsumer<T> buffer(@NotNull T... t) {
        return buffer(0, Integer.MAX_VALUE, t);
    }

    /**
     * 将一个指定范围的数据项添加到缓冲区。
     *
     * @param i  起始索引
     * @param i2 结束索引
     * @param t  可变参数
     * @return 缓冲消费者对象
     */
    default @NotNull IBufferedConsumer<T> buffer(int i, int i2, @NotNull T... t) {
        return buffer(i, i2, Arrays.asList(t).iterator());
    }

    /**
     * 将一个指定范围的数据项添加到缓冲区。
     *
     * @param i        起始索引
     * @param i2       结束索引
     * @param iterator 迭代器
     * @return 缓冲消费者对象
     */
    default @NotNull IBufferedConsumer<T> buffer(int i, int i2, Iterator<T> iterator) {
        if (iterator == null) {
            return this;
        }
        while (i++ < i2 && iterator.hasNext()) {
            buffer(iterator.next());
        }
        return this;
    }

    /**
     * 将一个指定范围的数据项添加到缓冲区。
     *
     * @param i    起始索引
     * @param i2   结束索引
     * @param list 列表
     * @return 缓冲消费者对象
     */
    default @NotNull IBufferedConsumer<T> buffer(int i, int i2, @NotNull List<T> list) {
        return buffer(i, i2, list.iterator());
    }

    /**
     * 将一个指定范围的数据项添加到缓冲区。
     *
     * @param i          起始索引
     * @param i2         结束索引
     * @param collection 集合
     * @return 缓冲消费者对象
     */
    default @NotNull IBufferedConsumer<T> buffer(int i, int i2, @NotNull Collection<T> collection) {
        return buffer(i, i2, collection.iterator());
    }

    /**
     * 检查缓冲区是否已满。
     *
     * @return 如果缓冲区已满，则返回true，否则返回false
     */
    boolean isBufferFull();
}